from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.future import select
from typing import List, Optional
from datetime import datetime

from app.models.logModel import Log
from app.schemas.logSchema import LogCreate
from sqlalchemy import func


# 创建日志
async def create_log(db: AsyncSession, log: LogCreate):
    """创建新的日志记录

    Args:
        db: 异步数据库会话
        log: 包含日志数据的LogCreate对象

    Returns:
        新创建的Log对象
    """
    db_log = Log(**log.model_dump())  # 将Schema转换为模型
    db.add(db_log)
    await db.commit()  # 提交事务
    await db.refresh(db_log)  # 刷新以获取数据库生成的字段（如ID和时间戳）
    return db_log


# 获取单个日志
async def get_log(db: AsyncSession, log_id: int):
    """根据ID获取单个日志记录

    Args:
        db: 异步数据库会话
        log_id: 要查询的日志ID

    Returns:
        找到的Log对象，如果不存在则返回None
    """
    result = await db.execute(select(Log).filter(Log.id == log_id))
    return result.scalars().first()

async def get_logs_with_count(
        db: AsyncSession,
        skip: int = 0,
        limit: int = 100,
        action: Optional[str] = None,
        # 新增多条件参数

):
    """获取日志列表和总数量"""
    # 基础查询
    query = select(Log)

    # 条件过滤
    if action:
        query = query.where(Log.action == action)

    # 获取总数
    count_query = select(func.count()).select_from(query.subquery())
    total = (await db.execute(count_query)).scalar_one()

    # 获取分页数据
    items = (await db.execute(
        query.order_by(Log.id.desc())  # 按时间倒序
        .offset(skip)
        .limit(limit)
    )).scalars().all()

    return {
        "total": total,
        "items": items,
        "skip": skip,
        "limit": limit
    }


# 获取日志列表（分页）
async def get_logs(
        db: AsyncSession,
        skip: int = 0,
        limit: int = 100,
        action: Optional[str] = None  # 新增：按 action 过滤
):
    """获取日志列表（支持分页和条件查询）

    Args:
        db: 异步数据库会话
        skip: 跳过的记录数
        limit: 每页返回的最大记录数
        action: 按操作类型过滤（可选）
    """
    query = select(Log)

    # 如果传入了 action，则添加过滤条件
    if action:
        query = query.where(Log.action == action)

    # 分页
    query = query.offset(skip).limit(limit)

    result = await db.execute(query)
    return result.scalars().all()


# async def get_logs(db: AsyncSession, skip: int = 0, limit: int = 100):
#     """获取日志列表，支持分页
#
#     Args:
#         db: 异步数据库会话
#         skip: 跳过的记录数（用于分页）
#         limit: 每页返回的最大记录数
#
#     Returns:
#         日志列表
#     """
#     result = await db.execute(select(Log).offset(skip).limit(limit))
#     return result.scalars().all()


# 更新日志
async def update_log(db: AsyncSession, log_id: int, log: LogCreate):
    """更新日志记录

    Args:
        db: 异步数据库会话
        log_id: 要更新的日志ID
        log: 包含更新数据的LogCreate对象

    Returns:
        更新后的Log对象，如果日志不存在则返回None
    """
    db_log = await get_log(db, log_id)
    if db_log:
        # 更新字段
        db_log.action = log.action
        db_log.details = log.details
        await db.commit()
        await db.refresh(db_log)
    return db_log


# 删除日志
async def delete_log(db: AsyncSession, log_id: int):
    """删除日志记录

    Args:
        db: 异步数据库会话
        log_id: 要删除的日志ID

    Returns:
        被删除的Log对象，如果日志不存在则返回None
    """
    db_log = await get_log(db, log_id)
    if db_log:
        await db.delete(db_log)
        await db.commit()
    return db_log